2004-11-10 Matthias Clasen <mclasen@redhat.com>
+ * gdk/linux-fb/*: Fix many sparse warnings. (#157253,
+ Kjartan Maraas.
+
* NEWS: Updates
2004-11-09 Matthias Clasen <mclasen@redhat.com>
2004-11-10 Matthias Clasen <mclasen@redhat.com>
+ * gdk/linux-fb/*: Fix many sparse warnings. (#157253,
+ Kjartan Maraas.
+
* NEWS: Updates
2004-11-09 Matthias Clasen <mclasen@redhat.com>
2004-11-10 Matthias Clasen <mclasen@redhat.com>
+ * gdk/linux-fb/*: Fix many sparse warnings. (#157253,
+ Kjartan Maraas.
+
* NEWS: Updates
2004-11-09 Matthias Clasen <mclasen@redhat.com>
2004-11-10 Matthias Clasen <mclasen@redhat.com>
+ * gdk/linux-fb/*: Fix many sparse warnings. (#157253,
+ Kjartan Maraas.
+
* NEWS: Updates
2004-11-09 Matthias Clasen <mclasen@redhat.com>
}
void
-gdk_fb_cursor_unhide()
+gdk_fb_cursor_unhide (void)
{
GdkFBDrawingContext *mydc = gdk_fb_cursor_dc;
GdkCursorPrivateFB *last_private;
}
guint
-gdk_fb_keyboard_modifiers ()
+gdk_fb_keyboard_modifiers (void)
{
return gdk_fb_keyboard->modifier_state;
}
}
static GdkFBDisplay *
-gdk_fb_display_new ()
+gdk_fb_display_new (void)
{
GdkFBDisplay *display;
gchar *fb_filename;
}
while ((i = read (fd, buf, sizeof(buf))) > 0)
- g_print ("Got %d bytes of junk from %s\n", mouse->file, i);
+ g_print ("Got %d bytes of junk from %s\n", i, mouse->file);
tcgetattr (fd, &tty);
tty.c_iflag = IGNBRK | IGNPAR;
GdkPixmap*
gdk_pixmap_foreign_new (GdkNativeWindow anid)
{
- return (GdkPixmap*) gdk_drawable_ref (anid);
+ return (GdkPixmap*) gdk_drawable_ref ((GdkDrawable *)anid);
}
GdkPixmap*
if (event_window)
{
event = gdk_event_make (event_window, GDK_SELECTION_REQUEST, TRUE);
- event->selection.requestor = requestor;
+ event->selection.requestor = (unsigned int)requestor;
event->selection.selection = selection;
event->selection.target = target;
event->selection.property = _gdk_selection_property;
if (!gdk_property_get (requestor,
_gdk_selection_property,
- 0/*AnyPropertyType?*/,
+ NULL/*AnyPropertyType?*/,
0, 0,
FALSE,
&prop_type, &prop_format, &prop_len,
if (!gdk_property_get (requestor,
_gdk_selection_property,
- 0/*AnyPropertyType?*/,
+ NULL/*AnyPropertyType?*/,
0, prop_len + 1,
FALSE,
&prop_type, &prop_format, &prop_len,
gdk_utf8_to_string_target (const gchar *str)
{
g_warning ("gdk_utf8_to_string_target() not implemented\n");
- return 0;
+ return NULL;
}
gboolean
gdk_window_foreign_new_for_display (GdkDisplay *display,
GdkNativeWindow anid)
{
- return (GdkWindow*) gdk_drawable_ref (anid);
+ return (GdkWindow*) gdk_drawable_ref ((GdkDrawable *)anid);
}
GdkWindow*
}
static double
-angleBetween (center, point1, point2)
- SppPointRec center, point1, point2;
+angleBetween (SppPointRec center, SppPointRec point1, SppPointRec point2)
{
double a1, a2, a;
}
static void
-translateBounds (b, x, y, fx, fy)
-miArcFacePtr b;
-int x, y;
-double fx, fy;
+translateBounds (miArcFacePtr b, int x, int y, double fx, double fy)
{
fx += x;
fy += y;
/*ARGSUSED*/
static void
-miArcCap (pDraw, pGC, pFace, end, xOrg, yOrg, xFtrans, yFtrans)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArcFacePtr pFace;
- int end;
- int xOrg, yOrg;
- double xFtrans, yFtrans;
+miArcCap (GdkDrawable *pDraw, GdkGC *pGC, miArcFacePtr pFace, int end,
+ int xOrg, int yOrg, double xFtrans, double yFtrans)
{
SppPointRec corner, otherCorner, center, endPoint, poly[5];
{
int cpt;
double width;
- double miDatan2 ();
SppArcRec arc;
SppPointPtr pArcPts;
arc.y = pCenter.y - width/2;
arc.width = width;
arc.height = width;
- arc.angle1 = -miDatan2 (pCorner.y - pCenter.y, pCorner.x - pCenter.x);
+ arc.angle1 = -(miDatan2 (pCorner.y - pCenter.y, pCorner.x - pCenter.x));
if(PTISEQUAL(pCenter, pEnd))
arc.angle2 = - 180.0;
else {
# define mod(a,b) ((a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
static double
-miDcos (a)
-double a;
+miDcos (double a)
{
int i;
}
static double
-miDsin (a)
-double a;
+miDsin (double a)
{
int i;
}
static double
-miDasin (v)
-double v;
+miDasin (double v)
{
if (v == 0)
return 0.0;
}
static double
-miDatan2 (dy, dx)
-double dy, dx;
+miDatan2 (double dy, double dx)
{
if (dy == 0) {
if (dx >= 0)
# define ADD_REALLOC_STEP 20
static void
-addCap (capsp, ncapsp, sizep, end, arcIndex)
- miArcCapPtr *capsp;
- int *ncapsp, *sizep;
- int end, arcIndex;
+addCap (miArcCapPtr *capsp, int *ncapsp, int *sizep, int end, int arcIndex)
{
int newsize;
miArcCapPtr cap;
}
static void
-addJoin (joinsp, njoinsp, sizep, end0, index0, phase0, end1, index1, phase1)
- miArcJoinPtr *joinsp;
- int *njoinsp, *sizep;
- int end0, index0, phase0, end1, index1, phase1;
+addJoin (miArcJoinPtr *joinsp, int *njoinsp, int *sizep, int end0, int index0,
+ int phase0, int end1, int index1, int phase1)
{
int newsize;
miArcJoinPtr join;
}
static miArcDataPtr
-addArc (arcsp, narcsp, sizep, xarc)
- miArcDataPtr *arcsp;
- int *narcsp, *sizep;
- miArc *xarc;
+addArc (miArcDataPtr *arcsp, int *narcsp, int *sizep, miArc *xarc)
{
int newsize;
miArcDataPtr arc;
# define dashXAngleStep (((double) (90 * 64)) / ((double) (DASH_MAP_SIZE - 1)))
static void
-computeDashMap (arcp, map)
- miArc *arcp;
- dashMap *map;
+computeDashMap (miArc *arcp, dashMap *map)
{
int di;
double a, x, y, prevx = 0.0, prevy = 0.0, dist;
for (iphase = 0; iphase < (isDoubleDash ? 2 : 1); iphase++) {
arcs[iphase].njoins = 0;
- arcs[iphase].joins = 0;
+ arcs[iphase].joins = NULL;
joinSize[iphase] = 0;
arcs[iphase].ncaps = 0;
- arcs[iphase].caps = 0;
+ arcs[iphase].caps = NULL;
capSize[iphase] = 0;
arcs[iphase].narcs = 0;
- arcs[iphase].arcs = 0;
+ arcs[iphase].arcs = NULL;
arcSize[iphase] = 0;
}
/*
* add dashed arcs to each bucket
*/
- arc = 0;
+ arc = NULL;
while (dashAngle != endAngle) {
prevDashAngle = dashAngle;
if (arcType == OTHER) {
}
static double
-angleToLength (angle, map)
- int angle;
- dashMap *map;
+angleToLength (int angle, dashMap *map)
{
double len, excesslen, sidelen = map->map[DASH_MAP_SIZE - 1], totallen;
int di;
*/
static int
-lengthToAngle (len, map)
- double len;
- dashMap *map;
+lengthToAngle (double len, dashMap *map)
{
double sidelen = map->map[DASH_MAP_SIZE - 1];
int angle, angleexcess;
*/
static void
-drawZeroArc (pDraw, pGC, tarc, lw, left, right)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArc *tarc;
- int lw;
- miArcFacePtr right, left;
+drawZeroArc (GdkDrawable *pDraw, GdkGC *pGC, miArc *tarc, int lw,
+ miArcFacePtr left, miArcFacePtr right)
{
double x0 = 0.0, y0 = 0.0, x1 = 0.0, y1 = 0.0, w, h, x, y;
double xmax, ymax, xmin, ymin;
*/
static void
-tailEllipseY (def, acc)
- struct arc_def *def;
- struct accelerators *acc;
+tailEllipseY (struct arc_def *def, struct accelerators *acc)
{
double t;
*/
static double
-outerXfromXY (x, y, def, acc)
- double x, y;
- struct arc_def *def;
- struct accelerators *acc;
+outerXfromXY (double x, double y,
+ struct arc_def *def, struct accelerators *acc)
{
return x + (x * acc->h2l) / sqrt (x*x * acc->h4 + y*y * acc->w4);
}
static double
-outerYfromXY (x, y, def, acc)
- double x, y;
- struct arc_def *def;
- struct accelerators *acc;
+outerYfromXY (double x, double y,
+ struct arc_def *def, struct accelerators *acc)
{
return y + (y * acc->w2l) / sqrt (x*x * acc->h4 + y*y * acc->w4);
}
static double
-innerXfromXY (x, y, def, acc)
- double x, y;
- struct arc_def *def;
- struct accelerators *acc;
+innerXfromXY (double x, double y,
+ struct arc_def *def, struct accelerators *acc)
{
return x - (x * acc->h2l) / sqrt (x*x * acc->h4 + y*y * acc->w4);
}
static double
-innerYfromXY (x, y, def, acc)
- double x, y;
- struct arc_def *def;
- struct accelerators *acc;
+innerYfromXY (double x, double y,
+ struct arc_def *def, struct accelerators *acc)
{
return y - (y * acc->w2l) / sqrt (x*x * acc->h4 + y*y * acc->w4);
}
static double
-innerYfromY (y, def, acc)
- double y;
- struct arc_def *def;
- struct accelerators *acc;
+innerYfromY (double y, struct arc_def *def, struct accelerators *acc)
{
double x;
}
static void
-computeLine (x1, y1, x2, y2, line)
- double x1, y1, x2, y2;
- struct line *line;
+computeLine (double x1, double y1, double x2, double y2, struct line *line)
{
if (y1 == y2)
line->valid = 0;
*/
static void
-computeAcc (tarc, lw, def, acc)
- miArc *tarc;
- int lw;
- struct arc_def *def;
- struct accelerators *acc;
+computeAcc (miArc *tarc, int lw, struct arc_def *def, struct accelerators *acc)
{
def->w = ((double) tarc->width) / 2.0;
def->h = ((double) tarc->height) / 2.0;
*/
static void
-computeBound (def, bound, acc, right, left)
- struct arc_def *def;
- struct arc_bound *bound;
- struct accelerators *acc;
- miArcFacePtr right, left;
+computeBound (struct arc_def *def, struct arc_bound *bound,
+ struct accelerators *acc, miArcFacePtr right, miArcFacePtr left)
{
double t;
double innerTaily;
*/
static double
-hookEllipseY (scan_y, bound, acc, left)
- double scan_y;
- struct arc_bound *bound;
- struct accelerators *acc;
- int left;
+hookEllipseY (double scan_y, struct arc_bound *bound,
+ struct accelerators *acc, int left)
{
double ret;
*/
static double
-hookX (scan_y, def, bound, acc, left)
- double scan_y;
- struct arc_def *def;
- struct arc_bound *bound;
- struct accelerators *acc;
- int left;
+hookX (double scan_y, struct arc_def *def,
+ struct arc_bound *bound, struct accelerators *acc, int left)
{
double ellipse_y, x;
double maxMin;
*/
static void
-arcSpan (y, lx, lw, rx, rw, def, bounds, acc, mask)
- int y;
- int lx;
- int lw;
- int rx;
- int rw;
- struct arc_def *def;
- struct arc_bound *bounds;
- struct accelerators *acc;
- int mask;
+arcSpan (int y, int lx, int lw, int rx, int rw,
+ struct arc_def *def, struct arc_bound *bounds,
+ struct accelerators *acc, int mask)
{
int linx, loutx, rinx, routx;
double x, altx;
}
static void
-arcSpan0 (lx, lw, rx, rw, def, bounds, acc, mask)
- int lx;
- int lw;
- int rx;
- int rw;
- struct arc_def *def;
- struct arc_bound *bounds;
- struct accelerators *acc;
- int mask;
+arcSpan0 (int lx, int lw, int rx, int rw,
+ struct arc_def *def, struct arc_bound *bounds,
+ struct accelerators *acc, int mask)
{
double x;
}
static void
-tailSpan (y, lw, rw, def, bounds, acc, mask)
- int y;
- int lw;
- int rw;
- struct arc_def *def;
- struct arc_bound *bounds;
- struct accelerators *acc;
- int mask;
+tailSpan (int y, int lw, int rw,
+ struct arc_def *def, struct arc_bound *bounds,
+ struct accelerators *acc, int mask)
{
double yy, xalt, x, lx, rx;
int n;
# define allocFinalSpan() (freeFinalSpans ?\
((tmpFinalSpan = freeFinalSpans), \
(freeFinalSpans = freeFinalSpans->next), \
- (tmpFinalSpan->next = 0), \
+ (tmpFinalSpan->next = NULL), \
tmpFinalSpan) : \
realAllocSpan ())
static struct finalSpanChunk *chunks;
struct finalSpan *
-realAllocSpan ()
+realAllocSpan (void)
{
register struct finalSpanChunk *newChunk;
register struct finalSpan *span;
span->next = span+1;
span++;
}
- span->next = 0;
+ span->next = NULL;
span = newChunk->data;
- span->next = 0;
+ span->next = NULL;
return span;
}
static void
-disposeFinalSpans ()
+disposeFinalSpans (void)
{
struct finalSpanChunk *chunk, *next;
next = chunk->next;
g_free (chunk);
}
- chunks = 0;
- freeFinalSpans = 0;
+ chunks = NULL;
+ freeFinalSpans = NULL;
g_free(finalSpans);
- finalSpans = 0;
+ finalSpans = NULL;
}
static void
-fillSpans (pDrawable, pGC)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
+fillSpans (GdkDrawable *pDrawable, GdkGC *pGC)
{
register struct finalSpan *span;
register GdkSpan* xSpan;
realFindSpan (y))
static struct finalSpan **
-realFindSpan (y)
- int y;
+realFindSpan (int y)
{
struct finalSpan **newSpans;
int newSize, newMiny, newMaxy;
}
static void
-newFinalSpan (y, xmin, xmax)
- int y;
- register int xmin, xmax;
+newFinalSpan (int y, register int xmin, register int xmax)
{
register struct finalSpan *x;
register struct finalSpan **f;
f = findSpan (y);
if (!f)
return;
- oldx = 0;
+ oldx = NULL;
for (;;) {
- prev = 0;
+ prev = NULL;
for (x = *f; x; x=x->next) {
if (x == oldx) {
prev = x;
}
static void
-mirrorSppPoint (quadrant, sppPoint)
- int quadrant;
- SppPointPtr sppPoint;
+mirrorSppPoint (int quadrant, SppPointPtr sppPoint)
{
switch (quadrant) {
case 0:
computeAcc (tarc, l, &def, &acc);
for (j = 0; j < sweepno; j++) {
mask = sweep[j].mask;
- passRight = passLeft = 0;
+ passRight = passLeft = NULL;
if (mask & (1 << rightq)) {
if (sweep[j].a0 == righta)
passRight = right;
}
static void
-drawQuadrant (def, acc, a0, a1, mask, right, left, spdata)
- struct arc_def *def;
- struct accelerators *acc;
- int a0, a1;
- int mask;
- miArcFacePtr right, left;
- miArcSpanData *spdata;
+drawQuadrant (struct arc_def *def, struct accelerators *acc,
+ int a0, int a1, int mask, miArcFacePtr right,
+ miArcFacePtr left, miArcSpanData *spdata)
{
struct arc_bound bound;
double yy, x, xalt;
#include <config.h>
#include "mi.h"
-static miDashPtr CheckDashStorage();
+static miDashPtr
+CheckDashStorage(miDashPtr *ppseg, int nseg, int *pnsegMax);
/* return a list of DashRec. there will be an extra
entry at the end holding the last point of the polyline.
#define sign(x) ((x)>0)?1:( ((x)<0)?-1:0 )
miDashPtr
-miDashLine(npt, ppt, nDash, pDash, offset, pnseg)
-int npt;
-GdkPoint* ppt;
-unsigned int nDash;
-unsigned char *pDash;
-unsigned int offset;
-int *pnseg;
+miDashLine(int npt, GdkPoint *ppt, unsigned int nDash,
+ unsigned char *pDash, unsigned int offset, int *pnseg)
{
GdkPoint pt1, pt2;
int lenCur; /* npt used from this dash */
*/
-static
-miDashPtr
-CheckDashStorage(ppseg, nseg, pnsegMax)
+static miDashPtr
+CheckDashStorage(miDashPtr *ppseg, int nseg, int *pnsegMax)
+#if 0
miDashPtr *ppseg; /* base pointer */
int nseg; /* number of segment we want to write to */
int *pnsegMax; /* size (in segments) of list so far */
+#endif
{
if (nseg > *pnsegMax)
{
}
void
-miStepDash (dist, pDashIndex, pDash, numInDashList, pDashOffset)
+miStepDash (int dist, int *pDashIndex, unsigned char *pDash,
+ int numInDashList, int *pDashOffset)
+#if 0
int dist; /* distance to step */
int *pDashIndex; /* current dash */
unsigned char *pDash; /* dash list */
int numInDashList; /* total length of dash list */
int *pDashOffset; /* offset into current dash */
+#endif
{
int dashIndex, dashOffset;
int totallen;
#define Dcos(d) cos((double)d*(M_PI/11520.0))
void
-miFillArcSetup(arc, info)
- register miArc *arc;
- register miFillArcRec *info;
+miFillArcSetup(register miArc *arc, register miFillArcRec *info)
{
info->y = arc->height >> 1;
info->dy = arc->height & 1;
}
void
-miFillArcDSetup(arc, info)
- register miArc *arc;
- register miFillArcDRec *info;
+miFillArcDSetup(register miArc *arc, register miFillArcDRec *info)
{
/* h^2 * (2x - 2xorg)^2 = w^2 * h^2 - w^2 * (2y - 2yorg)^2 */
/* even: xorg = yorg = 0 odd: xorg = .5, yorg = -.5 */
}
static void
-miGetArcEdge(arc, edge, k, top, left)
- register miArc *arc;
- register miSliceEdgePtr edge;
- int k;
- gboolean top, left;
+miGetArcEdge(register miArc *arc, register miSliceEdgePtr edge, int k,
+ gboolean top, gboolean left)
{
register int xady, y;
}
void
-miEllipseAngleToSlope (angle, width, height, dxp, dyp, d_dxp, d_dyp)
- int angle;
- int width;
- int height;
- int *dxp;
- int *dyp;
- double *d_dxp;
- double *d_dyp;
+miEllipseAngleToSlope (int angle, int width, int height, int *dxp, int *dyp,
+ double *d_dxp, double *d_dyp)
{
int dx, dy;
double d_dx, d_dy, scale;
}
static void
-miGetPieEdge(arc, angle, edge, top, left)
- register miArc *arc;
- register int angle;
- register miSliceEdgePtr edge;
- gboolean top, left;
+miGetPieEdge(register miArc *arc, register int angle,
+ register miSliceEdgePtr edge, gboolean top, gboolean left)
{
register int k;
int dx, dy;
- miEllipseAngleToSlope (angle, arc->width, arc->height, &dx, &dy, 0, 0);
+ miEllipseAngleToSlope (angle, arc->width, arc->height, &dx, &dy, NULL, NULL);
if (dy == 0)
{
}
void
-miFillArcSliceSetup(arc, slice, pGC)
- register miArc *arc;
- register miArcSliceRec *slice;
- GdkGC* pGC;
+miFillArcSliceSetup(register miArc *arc, register miArcSliceRec *slice,
+ GdkGC *pGC)
{
register int angle1, angle2;
}
static void
-miFillEllipseI(pDraw, pGC, arc)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArc *arc;
+miFillEllipseI(GdkDrawable *pDraw, GdkGC *pGC, miArc *arc)
{
register int x, y, e;
int yk, xk, ym, xm, dx, dy, xorg, yorg;
}
static void
-miFillEllipseD(pDraw, pGC, arc)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArc *arc;
+miFillEllipseD(GdkDrawable *pDraw, GdkGC *pGC, miArc *arc)
{
register int x, y;
int xorg, yorg, dx, dy, slw;
}
static void
-miFillArcSliceI(pDraw, pGC, arc)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArc *arc;
+miFillArcSliceI(GdkDrawable *pDraw, GdkGC *pGC, miArc *arc)
{
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
register int x, y, e;
}
static void
-miFillArcSliceD(pDraw, pGC, arc)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- miArc *arc;
+miFillArcSliceD(GdkDrawable *pDraw, GdkGC *pGC, miArc *arc)
{
register int x, y;
int dx, dy, xorg, yorg, slw;
* fill each arc as it comes.
*/
void
-miPolyFillArc(pDraw, pGC, narcs, parcs)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- int narcs;
- miArc *parcs;
+miPolyFillArc(GdkDrawable *pDraw, GdkGC *pGC, int narcs, miArc *parcs)
{
register int i;
register miArc *arc;
#define miFillInArcLower(slw) (((iny + dy) != 0) && \
((slw > 1) || (ine != inxk)))
-extern int miFreeArcCache(
-#if NeedFunctionPrototypes
- gpointer /*data*/,
- guint /*id*/
-#endif
-);
+extern int miFreeArcCache(gpointer data, guint id);
-extern struct finalSpan *realAllocSpan(
-#if NeedFunctionPrototypes
- void
-#endif
-);
+extern struct finalSpan *realAllocSpan(void);
-extern void miFillArcSetup(
-#if NeedFunctionPrototypes
- miArc * /*arc*/,
- miFillArcRec * /*info*/
-#endif
-);
+extern void miFillArcSetup(miArc *arc, miFillArcRec *info);
-extern void miFillArcDSetup(
-#if NeedFunctionPrototypes
- miArc * /*arc*/,
- miFillArcDRec * /*info*/
-#endif
-);
-
-extern void miEllipseAngleToSlope(
-#if NeedFunctionPrototypes
- int /*angle*/,
- int /*width*/,
- int /*height*/,
- int * /*dxp*/,
- int * /*dyp*/,
- double * /*d_dxp*/,
- double * /*d_dyp*/
-#endif
-);
+extern void miFillArcDSetup(miArc *arc, miFillArcDRec *info);
-extern void miFillArcSliceSetup(
-#if NeedFunctionPrototypes
- miArc * /*arc*/,
- miArcSliceRec * /*slice*/,
- GdkGC* /*pGC*/
-#endif
-);
+extern void miEllipseAngleToSlope(int angle, int width, int height, int *dxp,
+ int *dyp, double *d_dxp, double *d_dyp);
+
+extern void miFillArcSliceSetup(miArc *arc, miArcSliceRec *slice, GdkGC* pGC);
#endif
+
#else
#ifdef __GNUC__
#define ICEIL ICIEL
-static __inline int ICEIL(x)
- double x;
+static __inline int ICEIL(double x)
{
int _cTmp = x;
return ((x == _cTmp) || (x < 0.0)) ? _cTmp : _cTmp+1;
/* mifpolycon.c */
extern void miFillSppPoly(
-#if NeedFunctionPrototypes
- GdkDrawable* /*dst*/,
- GdkGC* /*pgc*/,
- int /*count*/,
- SppPointPtr /*ptsIn*/,
- int /*xTrans*/,
- int /*yTrans*/,
- double /*xFtrans*/,
- double /*yFtrans*/
-#endif
+ GdkDrawable* dst,
+ GdkGC* pgc,
+ int count,
+ SppPointPtr ptsIn,
+ int xTrans,
+ int yTrans,
+ double xFtrans,
+ double yFtrans
);
#endif /* MIFPOLY_H */
#include "mi.h"
#include "mifpoly.h"
-static int GetFPolyYBounds();
+static int
+GetFPolyYBounds(register SppPointPtr pts, int n, double yFtrans, int *by, int *ty);
#ifdef ICEILTEMPDECL
ICEILTEMPDECL
\f
/* Find the index of the point with the smallest y.also return the
* smallest and largest y */
-static
-int
-GetFPolyYBounds(pts, n, yFtrans, by, ty)
- register SppPointPtr pts;
- int n;
- double yFtrans;
- int *by, *ty;
+static int
+GetFPolyYBounds(register SppPointPtr pts, int n, double yFtrans, int *by, int *ty)
{
register SppPointPtr ptMin;
double ymin, ymax;
extern int miZeroLineScreenIndex;
extern int miZeroClipLine(
-#if NeedFunctionPrototypes
- int /*xmin*/,
- int /*ymin*/,
- int /*xmax*/,
- int /*ymax*/,
- int * /*new_x1*/,
- int * /*new_y1*/,
- int * /*new_x2*/,
- int * /*new_y2*/,
- unsigned int /*adx*/,
- unsigned int /*ady*/,
- int * /*pt1_clipped*/,
- int * /*pt2_clipped*/,
- int /*octant*/,
- unsigned int /*bias*/,
- int /*oc1*/,
- int /*oc2*/
-#endif
+ int xmin,
+ int ymin,
+ int xmax,
+ int ymax,
+ int * new_x1,
+ int * new_y1,
+ int * new_x2,
+ int * new_y2,
+ unsigned int adx,
+ unsigned int ady,
+ int * pt1_clipped,
+ int * pt2_clipped,
+ int octant,
+ unsigned int bias,
+ int oc1,
+ int oc2
);
#endif /* MILINE_H */
#include <config.h>
#include "mi.h"
-extern gboolean miFillGeneralPoly(
-#if NeedFunctionPrototypes
- GdkDrawable* /*dst*/,
- GdkGC* /*pgc*/,
- int /*count*/,
- GdkPoint* /*ptsIn*/
-#endif
-);
+extern gboolean miFillGeneralPoly(GdkDrawable* dst, GdkGC* pgc,
+ int count, GdkPoint* ptsIn);
void
-miFillPolygon(dst, pgc, shape, mode, count, pPts)
- GdkDrawable* dst;
- register GdkGC* pgc;
- int shape, mode;
- register int count;
- GdkPoint* pPts;
+miFillPolygon(GdkDrawable *dst, register GdkGC *pgc, int shape,
+ int mode, register int count, GdkPoint *pPts)
{
if (count == 0)
return;
/* mipolyutil.c */
-extern gboolean miInsertEdgeInET(
-#if NeedFunctionPrototypes
- EdgeTable * /*ET*/,
- EdgeTableEntry * /*ETE*/,
- int /*scanline*/,
- ScanLineListBlock ** /*SLLBlock*/,
- int * /*iSLLBlock*/
-#endif
-);
-
-extern gboolean miCreateETandAET(
-#if NeedFunctionPrototypes
- int /*count*/,
- GdkPoint* /*pts*/,
- EdgeTable * /*ET*/,
- EdgeTableEntry * /*AET*/,
- EdgeTableEntry * /*pETEs*/,
- ScanLineListBlock * /*pSLLBlock*/
-#endif
-);
+extern gboolean miInsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
+ ScanLineListBlock **SLLBlock, int *iSLLBlock);
-extern void miloadAET(
-#if NeedFunctionPrototypes
- EdgeTableEntry * /*AET*/,
- EdgeTableEntry * /*ETEs*/
-#endif
-);
+extern gboolean miCreateETandAET(int count, GdkPoint* pts, EdgeTable *ET,
+ EdgeTableEntry *AET, EdgeTableEntry *pETEs,
+ ScanLineListBlock *pSLLBlock);
-extern void micomputeWAET(
-#if NeedFunctionPrototypes
- EdgeTableEntry * /*AET*/
-#endif
-);
+extern void miloadAET(EdgeTableEntry *AET, EdgeTableEntry *ETEs);
-extern int miInsertionSort(
-#if NeedFunctionPrototypes
- EdgeTableEntry * /*AET*/
-#endif
-);
+extern void micomputeWAET(EdgeTableEntry *AET);
-extern void miFreeStorage(
-#if NeedFunctionPrototypes
- ScanLineListBlock * /*pSLLBlock*/
-#endif
-);
+extern int miInsertionSort(EdgeTableEntry *AET);
+
+extern void miFreeStorage(ScanLineListBlock *pSLLBlock);
#endif
*/
gboolean
-miFillGeneralPoly(dst, pgc, count, ptsIn)
- GdkDrawable* dst;
- GdkGC* pgc;
- int count; /* number of points */
- GdkPoint* ptsIn; /* the points */
+miFillGeneralPoly(GdkDrawable *dst, GdkGC *pgc, int count, GdkPoint *ptsIn)
{
register EdgeTableEntry *pAET; /* the Active Edge Table */
register int y; /* the current scanline */
*
*/
gboolean
-miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
- EdgeTable *ET;
- EdgeTableEntry *ETE;
- int scanline;
- ScanLineListBlock **SLLBlock;
- int *iSLLBlock;
+miInsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
+ ScanLineListBlock **SLLBlock, int *iSLLBlock)
{
register EdgeTableEntry *start, *prev;
register ScanLineList *pSLL, *pPrevSLL;
*/
gboolean
-miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
- register int count;
- register GdkPoint* pts;
- EdgeTable *ET;
- EdgeTableEntry *AET;
- register EdgeTableEntry *pETEs;
- ScanLineListBlock *pSLLBlock;
+miCreateETandAET(register int count, register GdkPoint *pts, EdgeTable *ET,
+ EdgeTableEntry *AET, register EdgeTableEntry *pETEs,
+ ScanLineListBlock *pSLLBlock)
{
register GdkPoint* top, *bottom;
register GdkPoint* PrevPt, *CurrPt;
*/
void
-miloadAET(AET, ETEs)
- register EdgeTableEntry *AET, *ETEs;
+miloadAET(register EdgeTableEntry *AET, register EdgeTableEntry *ETEs)
{
register EdgeTableEntry *pPrevAET;
register EdgeTableEntry *tmp;
*
*/
void
-micomputeWAET(AET)
- register EdgeTableEntry *AET;
+micomputeWAET(register EdgeTableEntry *AET)
{
register EdgeTableEntry *pWETE;
register int inside = 1;
*/
int
-miInsertionSort(AET)
- register EdgeTableEntry *AET;
+miInsertionSort(register EdgeTableEntry *AET)
{
register EdgeTableEntry *pETEchase;
register EdgeTableEntry *pETEinsert;
* Clean up our act.
*/
void
-miFreeStorage(pSLLBlock)
- register ScanLineListBlock *pSLLBlock;
+miFreeStorage(register ScanLineListBlock *pSLLBlock)
{
register ScanLineListBlock *tmpSLLBlock;
*/
-void miInitSpanGroup(spanGroup)
- SpanGroup *spanGroup;
+void miInitSpanGroup(SpanGroup *spanGroup)
{
spanGroup->size = 0;
spanGroup->count = 0;
#define YMIN(spans) (spans->points[0].y)
#define YMAX(spans) (spans->points[spans->count-1].y)
-void miSubtractSpans (spanGroup, sub)
- SpanGroup *spanGroup;
- Spans *sub;
+void miSubtractSpans (SpanGroup *spanGroup, Spans *sub)
{
int i, subCount, spansCount;
int ymin, ymax, xmin, xmax;
}
}
-void miAppendSpans(spanGroup, otherGroup, spans)
- SpanGroup *spanGroup;
- SpanGroup *otherGroup;
- Spans *spans;
+void miAppendSpans(SpanGroup *spanGroup, SpanGroup *otherGroup, Spans *spans)
{
register int ymin, ymax;
register int spansCount;
}
} /* AppendSpans */
-void miFreeSpanGroup(spanGroup)
- SpanGroup *spanGroup;
+void miFreeSpanGroup(SpanGroup *spanGroup)
{
if (spanGroup->group != NULL) g_free(spanGroup->group);
}
-static void QuickSortSpansX(points, numSpans)
- register GdkSpan points[];
- register int numSpans;
+static void QuickSortSpansX(register GdkSpan points[], register int numSpans)
{
register int x;
register int i, j, m;
} /* QuickSortSpans */
-static int UniquifySpansX(spans, newPoints, newWidths)
- Spans *spans;
- register GdkSpan *newPoints;
+static int UniquifySpansX(Spans *spans, register GdkSpan *newPoints)
{
register int newx1, newx2, oldpt, i, y;
GdkSpan *oldPoints, *startNewPoints = newPoints;
} /* UniquifySpansX */
void
-miDisposeSpanGroup (spanGroup)
- SpanGroup *spanGroup;
+miDisposeSpanGroup (SpanGroup *spanGroup)
{
int i;
Spans *spans;
}
}
-void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- SpanGroup *spanGroup;
+void miFillUniqueSpanGroup(GdkDrawable *pDraw, GdkGC *pGC, SpanGroup *spanGroup)
{
register int i;
register Spans *spans;
}
-void miFillSpanGroup(pDraw, pGC, spanGroup)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- SpanGroup *spanGroup;
+void miFillSpanGroup(GdkDrawable *pDraw, GdkGC *pGC, SpanGroup *spanGroup)
{
register int i;
register Spans *spans;
} SpanGroup;
/* Initialize SpanGroup. MUST BE DONE before use. */
-extern void miInitSpanGroup(
-#if NeedFunctionPrototypes
- SpanGroup * /*spanGroup*/
-#endif
-);
+extern void miInitSpanGroup(SpanGroup *spanGroup);
/* Add a Spans to a SpanGroup. The spans MUST BE in y-sorted order */
-extern void miAppendSpans(
-#if NeedFunctionPrototypes
- SpanGroup * /*spanGroup*/,
- SpanGroup * /*otherGroup*/,
- Spans * /*spans*/
-#endif
-);
+extern void miAppendSpans(SpanGroup *spanGroup, SpanGroup *otherGroup,
+ Spans *spans);
/* Paint a span group, possibly with some overlap */
-extern void miFillSpanGroup(
-#if NeedFunctionPrototypes
- GdkDrawable* /*pDraw*/,
- GdkGC* /*pGC*/,
- SpanGroup * /*spanGroup*/
-#endif
-);
+extern void miFillSpanGroup(GdkDrawable* pDraw, GdkGC* pGC,
+ SpanGroup *spanGroup);
/* Paint a span group, insuring that each pixel is painted at most once */
-extern void miFillUniqueSpanGroup(
-#if NeedFunctionPrototypes
- GdkDrawable* /*pDraw*/,
- GdkGC* /*pGC*/,
- SpanGroup * /*spanGroup*/
-#endif
-);
+extern void miFillUniqueSpanGroup(GdkDrawable* pDraw, GdkGC* pGC,
+ SpanGroup *spanGroup);
/* Free up data in a span group. MUST BE DONE or you'll suffer memory leaks */
-extern void miFreeSpanGroup(
-#if NeedFunctionPrototypes
- SpanGroup * /*spanGroup*/
-#endif
-);
-
-extern void miSubtractSpans(
-#if NeedFunctionPrototypes
- SpanGroup * /*spanGroup*/,
- Spans * /*sub*/
-#endif
-);
-
-extern void miDisposeSpanGroup(
-#if NeedFunctionPrototypes
- SpanGroup * /*spanGroup*/
-#endif
-);
-
-extern int miClipSpans(
-#if NeedFunctionPrototypes
- GdkRegion* /*prgnDst*/,
- GdkPoint* /*ppt*/,
- int * /*pwidth*/,
- int /*nspans*/,
- GdkPoint* /*pptNew*/,
- int * /*pwidthNew*/,
- int /*fSorted*/
-#endif
-);
+extern void miFreeSpanGroup(SpanGroup *spanGroup);
+
+extern void miSubtractSpans(SpanGroup *spanGroup, Spans *sub);
+
+extern void miDisposeSpanGroup(SpanGroup *spanGroup);
+
+extern int miClipSpans(GdkRegion* prgnDst, GdkPoint* ppt,
+ int *pwidth, int nspans, GdkPoint* pptNew,
+ int *pwidthNew, int fSorted);
/* Rops which must use span groups */
#define miSpansCarefulRop(rop) (((rop) & 0xc) == 0x8 || ((rop) & 0x3) == 0x2)
*/
void
-miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
- left, right, left_count, right_count)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
- GdkColor *pixel;
- SpanDataPtr spanData;
- int y; /* start y coordinate */
- int overall_height; /* height of entire segment */
- PolyEdgePtr left, right;
- int left_count, right_count;
+miFillPolyHelper (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, int y, int overall_height,
+ PolyEdgePtr left, PolyEdgePtr right, int left_count,
+ int right_count)
{
register int left_x = 0, left_e = 0;
int left_stepx = 0;
}
static void
-miFillRectPolyHelper (pDrawable, pGC, pixel, spanData, x, y, w, h)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
- GdkColor* pixel;
- SpanDataPtr spanData;
- int x, y, w, h;
+miFillRectPolyHelper (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, int x, int y, int w, int h)
{
register GdkSpan* ppt;
GdkColor oldPixel;
}
/* static */ int
-miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
- double x0, y0;
- double k; /* x0 * dy - y0 * dx */
- register int dx, dy;
- int xi, yi;
- int left;
- register PolyEdgePtr edge;
+miPolyBuildEdge (double x0, double y0, double k, register int dx,
+ register int dy, int xi, int yi, int left,
+ register PolyEdgePtr edge)
{
int x, y, e;
int xady;
#define StepAround(v, incr, max) (((v) + (incr) < 0) ? (max - 1) : ((v) + (incr) == max) ? 0 : ((v) + (incr)))
/* static */ int
-miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright, h)
- register PolyVertexPtr vertices;
- register PolySlopePtr slopes;
- int count;
- int xi, yi;
- PolyEdgePtr left, right;
- int *pnleft, *pnright;
- int *h;
+miPolyBuildPoly (register PolyVertexPtr vertices, register PolySlopePtr slopes,
+ int count, int xi, int yi, PolyEdgePtr left, PolyEdgePtr right,
+ int *pnleft, int *pnright, int *h)
{
int top, bottom;
double miny, maxy;
}
static void
-miLineOnePoint (pDrawable, pGC, pixel, spanData, x, y)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
- GdkColor* pixel;
- SpanDataPtr spanData;
- int x, y;
+miLineOnePoint (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, int x, int y)
{
GdkColor oldPixel;
GdkSpan span;
}
static void
-miLineJoin (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel, SpanDataPtr spanData, LineFacePtr pLeft, LineFacePtr pRight)
+miLineJoin (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, LineFacePtr pLeft, LineFacePtr pRight)
{
double mx, my;
double denom = 0.0;
}
static int
-miLineArcI (pDraw, pGC, xorg, yorg, points)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- int xorg, yorg;
- GdkSpan* points;
+miLineArcI (GdkDrawable *pDraw, GdkGC *pGC, int xorg, int yorg, GdkSpan *points)
{
register GdkSpan* tpts, *bpts;
register int x, y, e, ex, slw;
}
static int
-miLineArcD (pDraw, pGC, xorg, yorg, points,
- edge1, edgey1, edgeleft1, edge2, edgey2, edgeleft2)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- double xorg, yorg;
- GdkSpan* points;
- PolyEdgePtr edge1, edge2;
- int edgey1, edgey2;
- gboolean edgeleft1, edgeleft2;
+miLineArcD (GdkDrawable *pDraw, GdkGC *pGC, double xorg, double yorg, GdkSpan *points,
+ PolyEdgePtr edge1, int edgey1, gboolean edgeleft1,
+ PolyEdgePtr edge2, int edgey2, gboolean edgeleft2)
{
register GdkSpan* pts;
double radius, x0, y0, el, er, yk, xlk, xrk, k;
}
int
-miRoundJoinFace (face, edge, leftEdge)
- register LineFacePtr face;
- register PolyEdgePtr edge;
- gboolean *leftEdge;
+miRoundJoinFace (register LineFacePtr face, register PolyEdgePtr edge,
+ gboolean *leftEdge)
{
int y;
int dx, dy;
}
void
-miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
- register LineFacePtr pLeft, pRight;
- PolyEdgePtr edge1, edge2;
- int *y1, *y2;
- gboolean *left1, *left2;
+miRoundJoinClip (register LineFacePtr pLeft, register LineFacePtr pRight,
+ PolyEdgePtr edge1, PolyEdgePtr edge2, int *y1, int *y2,
+ gboolean *left1, gboolean *left2)
{
double denom;
}
int
-miRoundCapClip (face, isInt, edge, leftEdge)
- register LineFacePtr face;
- gboolean isInt;
- register PolyEdgePtr edge;
- gboolean *leftEdge;
+miRoundCapClip (register LineFacePtr face, gboolean isInt,
+ register PolyEdgePtr edge, gboolean *leftEdge)
{
int y;
register int dx, dy;
}
static void
-miLineArc (pDraw, pGC, pixel, spanData, leftFace, rightFace, xorg, yorg, isInt)
- GdkDrawable* pDraw;
- register GdkGC* pGC;
- GdkColor* pixel;
- SpanDataPtr spanData;
- register LineFacePtr leftFace, rightFace;
- double xorg, yorg;
- gboolean isInt;
+miLineArc (GdkDrawable *pDraw, GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, register LineFacePtr leftFace,
+ register LineFacePtr rightFace, double xorg, double yorg,
+ gboolean isInt)
{
GdkSpan* points;
int xorgi = 0, yorgi = 0;
}
void
-miLineProjectingCap (pDrawable, pGC, pixel, spanData, face, isLeft, xorg, yorg, isInt)
- GdkDrawable* pDrawable;
- register GdkGC* pGC;
- GdkColor *pixel;
- SpanDataPtr spanData;
- register LineFacePtr face;
- gboolean isLeft;
- double xorg, yorg;
- gboolean isInt;
+miLineProjectingCap (GdkDrawable *pDrawable, register GdkGC *pGC, GdkColor *pixel,
+ SpanDataPtr spanData, register LineFacePtr face,
+ gboolean isLeft, double xorg, double yorg, gboolean isInt)
{
int xorgi = 0, yorgi = 0;
int lw;
}
SpanDataPtr
-miSetupSpanData (pGC, spanData, npt)
- register GdkGC* pGC;
- SpanDataPtr spanData;
- int npt;
+miSetupSpanData (register GdkGC *pGC, SpanDataPtr spanData, int npt)
{
if ((npt < 3 && GDK_GC_FBDATA(pGC)->values.cap_style != GDK_CAP_ROUND) || miSpansEasyRop(GDK_GC_FBDATA(pGC)->alu))
return (SpanDataPtr) NULL;
}
void
-miCleanupSpanData (pDrawable, pGC, spanData)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
- SpanDataPtr spanData;
+miCleanupSpanData (GdkDrawable *pDrawable, GdkGC *pGC, SpanDataPtr spanData)
{
if (GDK_GC_FBDATA(pGC)->values.line_style == GDK_LINE_DOUBLE_DASH)
{
}
void
-miWideLine (pDrawable, pGC, mode, npt, pPts)
- GdkDrawable* pDrawable;
- register GdkGC* pGC;
- int mode;
- register int npt;
- register GdkPoint* pPts;
+miWideLine (GdkDrawable *pDrawable, GdkGC *pGC, int mode,
+ register int npt, register GdkPoint *pPts)
{
int x1, y1, x2, y2;
SpanDataRec spanDataRec;
#define V_LEFT 3
static void
-miWideDashSegment (pDrawable, pGC, spanData, pDashOffset, pDashIndex,
- x1, y1, x2, y2, projectLeft, projectRight, leftFace, rightFace)
- GdkDrawable* pDrawable;
- register GdkGC* pGC;
- int *pDashOffset, *pDashIndex;
- SpanDataPtr spanData;
- int x1, y1, x2, y2;
- gboolean projectLeft, projectRight;
- LineFacePtr leftFace, rightFace;
+miWideDashSegment (GdkDrawable *pDrawable, register GdkGC *pGC,
+ SpanDataPtr spanData, int *pDashOffset, int *pDashIndex,
+ int x1, int y1, int x2, int y2, gboolean projectLeft,
+ gboolean projectRight, LineFacePtr leftFace,
+ LineFacePtr rightFace)
{
int dashIndex, dashRemain;
unsigned char *pDash;
}
void
-miWideDash (pDrawable, pGC, mode, npt, pPts)
- GdkDrawable* pDrawable;
- register GdkGC* pGC;
- int mode;
- register int npt;
- register GdkPoint* pPts;
+miWideDash (GdkDrawable *pDrawable, register GdkGC *pGC, int mode,
+ register int npt, register GdkPoint *pPts)
{
int x1, y1, x2, y2;
GdkColor pixel;
/* these are stubs to allow old ddx miValidateGCs to work without change */
void
-miMiter()
+miMiter(void)
{
}
void
-miNotMiter()
+miNotMiter(void)
{
}
#else
#ifdef __GNUC__
#define ICEIL ICIEL
-static __inline int ICEIL(x)
- double x;
+static __inline int ICEIL(double x)
{
int _cTmp = x;
return ((x == _cTmp) || (x < 0.0)) ? _cTmp : _cTmp+1;
#endif
#endif
-extern void miFillPolyHelper(
-#if NeedFunctionPrototypes
- GdkDrawable* /*pDrawable*/,
- GdkGC* /*pGC*/,
- GdkColor * /*pixel*/,
- SpanDataPtr /*spanData*/,
- int /*y*/,
- int /*overall_height*/,
- PolyEdgePtr /*left*/,
- PolyEdgePtr /*right*/,
- int /*left_count*/,
- int /*right_count*/
-#endif
-);
-extern int miRoundJoinFace(
-#if NeedFunctionPrototypes
- LineFacePtr /*face*/,
- PolyEdgePtr /*edge*/,
- gboolean * /*leftEdge*/
-#endif
-);
-
-extern void miRoundJoinClip(
-#if NeedFunctionPrototypes
- LineFacePtr /*pLeft*/,
- LineFacePtr /*pRight*/,
- PolyEdgePtr /*edge1*/,
- PolyEdgePtr /*edge2*/,
- int * /*y1*/,
- int * /*y2*/,
- gboolean * /*left1*/,
- gboolean * /*left2*/
-#endif
-);
-
-extern int miRoundCapClip(
-#if NeedFunctionPrototypes
- LineFacePtr /*face*/,
- gboolean /*isInt*/,
- PolyEdgePtr /*edge*/,
- gboolean * /*leftEdge*/
-#endif
-);
-
-extern void miLineProjectingCap(
-#if NeedFunctionPrototypes
- GdkDrawable* /*pDrawable*/,
- GdkGC* /*pGC*/,
- GdkColor * /*pixel*/,
- SpanDataPtr /*spanData*/,
- LineFacePtr /*face*/,
- gboolean /*isLeft*/,
- double /*xorg*/,
- double /*yorg*/,
- gboolean /*isInt*/
-#endif
-);
+extern void miFillPolyHelper(GdkDrawable* pDrawable, GdkGC* pGC,
+ GdkColor * pixel, SpanDataPtr spanData, int y,
+ int overall_height, PolyEdgePtr left,
+ PolyEdgePtr right, int left_count,
+ int right_count);
-extern SpanDataPtr miSetupSpanData(
-#if NeedFunctionPrototypes
- GdkGC* /*pGC*/,
- SpanDataPtr /*spanData*/,
- int /*npt*/
-#endif
-);
+extern int miRoundJoinFace(LineFacePtr face, PolyEdgePtr edge,
+ gboolean * leftEdge);
-extern void miCleanupSpanData(
-#if NeedFunctionPrototypes
- GdkDrawable* /*pDrawable*/,
- GdkGC* /*pGC*/,
- SpanDataPtr /*spanData*/
-#endif
-);
+extern void miRoundJoinClip(LineFacePtr pLeft, LineFacePtr pRight,
+ PolyEdgePtr edge1, PolyEdgePtr edge2, int *y1,
+ int *y2, gboolean *left1, gboolean *left2);
+
+extern int miRoundCapClip(LineFacePtr face, gboolean isInt, PolyEdgePtr edge,
+ gboolean *leftEdge);
+
+extern void miLineProjectingCap(GdkDrawable* pDrawable, GdkGC* pGC,
+ GdkColor *pixel, SpanDataPtr spanData,
+ LineFacePtr face, gboolean isLeft,
+ double xorg, double yorg, gboolean isInt);
+
+extern SpanDataPtr miSetupSpanData(GdkGC* pGC, SpanDataPtr spanData, int npt);
+
+extern void miCleanupSpanData(GdkDrawable* pDrawable, GdkGC* pGC,
+ SpanDataPtr spanData);
extern int miPolyBuildEdge(double x0, double y0, double k, int dx, int dy,
int xi, int yi, int left, PolyEdgePtr edge);
*
*/
int
-miZeroClipLine(xmin, ymin, xmax, ymax,
- new_x1, new_y1, new_x2, new_y2,
- adx, ady,
- pt1_clipped, pt2_clipped, octant, bias, oc1, oc2)
- int xmin, ymin, xmax, ymax;
- int *new_x1, *new_y1, *new_x2, *new_y2;
- int *pt1_clipped, *pt2_clipped;
- unsigned int adx, ady;
- int octant;
- unsigned int bias;
- int oc1, oc2;
+miZeroClipLine(int xmin, int ymin, int xmax, int ymax,
+ int *new_x1, int *new_y1, int *new_x2, int *new_y2,
+ unsigned int adx, unsigned int ady,
+ int *pt1_clipped, int *pt2_clipped, int octant,
+ unsigned int bias, int oc1, int oc2)
{
int swapped = 0;
int clipDone = 0;
}
void
-miZeroLine(pDraw, pGC, mode, npt, pptInit)
- GdkDrawable* pDraw;
- GdkGC* pGC;
- int mode; /* Origin or Previous */
- int npt; /* number of points */
- GdkPoint* pptInit;
+miZeroLine(GdkDrawable *pDraw, GdkGC *pGC,
+ int mode, int npt, GdkPoint *pptInit)
{
int Nspans, current_y = 0;
GdkPoint* ppt;
}
void
-miZeroDashLine(dst, pgc, mode, nptInit, pptInit)
-GdkDrawable* dst;
-GdkGC* pgc;
-int mode;
-int nptInit; /* number of points in polyline */
-GdkPoint *pptInit; /* points in the polyline */
+miZeroDashLine(GdkDrawable *dst, GdkGC *pgc,
+ int mode, int nptInit, GdkPoint *pptInit)
{
/* XXX kludge until real zero-width dash code is written */
GDK_GC_FBDATA(pgc)->values.line_width = 1;
projects / gtk4.git / commitdiff